home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / gnustuff / minix / gccdif~1.z / gccdif~1 / gcc-1.36.diff < prev    next >
Encoding:
Text File  |  1989-09-30  |  40.6 KB  |  1,672 lines
  1. *** ../../../Gnu/gcc-1.36/cccp.c    Mon Sep 11 23:43:13 1989
  2. --- cccp.c    Sat Sep 30 20:51:53 1989
  3. ***************
  4. *** 23,28 ****
  5. --- 23,30 ----
  6.   
  7.   typedef unsigned char U_CHAR;
  8.   
  9. + #ifndef atarist
  10. + 
  11.   #ifdef EMACS
  12.   #define NO_SHORTNAMES
  13.   #include "../src/config.h"
  14. ***************
  15. *** 50,66 ****
  16.   
  17.   #ifndef VMS
  18.   #include <sys/file.h>
  19. ! #ifndef USG
  20.   #include <sys/time.h>        /* for __DATE__ and __TIME__ */
  21.   #include <sys/resource.h>
  22.   #else
  23.   #define index strchr
  24.   #define rindex strrchr
  25.   #include <time.h>
  26.   #include <fcntl.h>
  27. ! #endif /* USG */
  28.   #endif /* not VMS */
  29. !   
  30.   /* VMS-specific definitions */
  31.   #ifdef VMS
  32.   #include <time.h>
  33. --- 52,86 ----
  34.   
  35.   #ifndef VMS
  36.   #include <sys/file.h>
  37. ! #if (!(defined(USG) || defined(atariminix)))
  38.   #include <sys/time.h>        /* for __DATE__ and __TIME__ */
  39.   #include <sys/resource.h>
  40.   #else
  41. + #ifndef atariminix
  42.   #define index strchr
  43.   #define rindex strrchr
  44. + #endif
  45.   #include <time.h>
  46.   #include <fcntl.h>
  47. ! #endif /* USG or atariminix */
  48.   #endif /* not VMS */
  49. ! 
  50. ! #else        /* atarist */
  51. ! 
  52. ! #include <ctype.h>
  53. ! #include <stdio.h>
  54. ! #include <types.h>
  55. ! #include <stat.h>
  56. ! #include <file.h>
  57. ! #include <time.h>
  58. ! #include "stddef.h"
  59. ! 
  60. ! extern long _stksize = 524288;    /* want big stack cause include files
  61. !                    get alloca'ed there */
  62. ! 
  63. ! #endif        /* atarist */
  64. ! 
  65. !  
  66.   /* VMS-specific definitions */
  67.   #ifdef VMS
  68.   #include <time.h>
  69. ***************
  70. *** 249,268 ****
  71. --- 269,327 ----
  72.   /* #include "file" looks in source file dir, then stack. */
  73.   /* #include <file> just looks in the stack. */
  74.   /* -I directories are added to the end, then the defaults are added. */
  75. + #ifdef atarist
  76. + 
  77. + struct file_name_list include_canned_defaults[] =
  78. +   {
  79. +     { &include_canned_defaults[1], "\\gnu\\lib" },
  80. +     { 0, "\\gnu\\include" }
  81. +   };
  82. + 
  83. + struct file_name_list * include_defaults = &include_canned_defaults[0];
  84. + 
  85. + #else
  86. + 
  87.   struct file_name_list include_defaults[] =
  88.     {
  89.   #ifndef VMS
  90. + #ifdef CROSSATARI
  91. +     { 0, CROSSINC }
  92. + #else
  93. + #ifdef atariminix
  94. +     { 0, "/usr/local/gcc-include" }
  95. + #else
  96.       { &include_defaults[1], GCC_INCLUDE_DIR },
  97.       { &include_defaults[2], "/usr/include" },
  98.       { 0, "/usr/local/include" }
  99. + #endif
  100. + #endif
  101.   #else
  102.       { &include_defaults[1], "GNU_CC_INCLUDE:" },       /* GNU includes */
  103.       { &include_defaults[2], "SYS$SYSROOT:[SYSLIB.]" }, /* VAX-11 "C" includes */
  104.       { 0, "" },    /* This makes normal VMS filespecs work OK */
  105.   #endif /* VMS */
  106.     };
  107. + #endif /* atarist */
  108.   
  109.   /* These are used instead of the above, for C++.  */
  110. + #ifdef atarist
  111. + 
  112. + struct file_name_list include_canned_cplusplus_defaults[] =
  113. +   {
  114. +     { &include_canned_defaults[1], "\\gnu\\lib" },
  115. +     { 0, "\\gnu\\include" }
  116. +   };
  117. + 
  118. + struct file_name_list * cplusplus_include_defaults =
  119. +                     &include_canned_cplusplus_defaults[0];
  120. + 
  121. + #else
  122. + 
  123. + #ifdef atariminix
  124. + #define GPLUSPLUS_INCLUDE_DIR "/usr/local/g++-include"
  125. + #define GCC_INCLUDE_DIR "/usr/local/gcc-include"
  126. + #endif
  127. + 
  128.   struct file_name_list cplusplus_include_defaults[] =
  129.     {
  130.   #ifndef VMS
  131. ***************
  132. *** 270,276 ****
  133. --- 329,339 ----
  134.       { &cplusplus_include_defaults[1], GPLUSPLUS_INCLUDE_DIR },
  135.       /* Use GNU CC specific header files.  */
  136.       { &cplusplus_include_defaults[2], GCC_INCLUDE_DIR },
  137. + #ifdef CROSSATARI
  138. +     { 0, CROSSINC }
  139. + #else
  140.       { 0, "/usr/include" }
  141. + #endif
  142.   #else
  143.       { &cplusplus_include_defaults[1], "GNU_GXX_INCLUDE:" },
  144.       { &cplusplus_include_defaults[2], "GNU_CC_INCLUDE:" },
  145. ***************
  146. *** 279,284 ****
  147. --- 342,348 ----
  148.       { 0, "" },    /* This makes normal VMS filespecs work OK */
  149.   #endif /* VMS */
  150.     };
  151. + #endif /* atarist */
  152.   
  153.   struct file_name_list *include = 0;    /* First dir to search */
  154.       /* First dir to search for <file> */
  155. ***************
  156. *** 507,513 ****
  157. --- 571,631 ----
  158.   /* Nonzero means -I- has been seen,
  159.      so don't look for #include "foo" the source-file directory.  */
  160.   int ignore_srcdir;
  161. +  
  162. + #ifdef atarist
  163. + /* a little frobule to filter incoming file data */
  164. + int eunuchs_read(f, buf, size)
  165. + int f;
  166. + char * buf;
  167. + int size;
  168. + {
  169. +   char local_buf[1024];
  170. +   register int result_size;
  171. +   register char * local_bufp, * target_bufp;
  172. +   register int buf_size, size_read;
  173. + 
  174. +   for (result_size = 0, target_bufp = buf ; size > 0 ; size -= 1024)
  175. + /* do a buffer */
  176. +       {
  177. +     if (size > 1024)
  178. +         buf_size = 1024;
  179. +         else
  180. +             buf_size = size;
  181. +     size_read = read(f, &local_buf, buf_size);
  182. +     for (local_bufp = (char * ) &local_buf; size_read > 0 ; size_read--)
  183. +         if (*local_bufp == '\r')
  184. +             local_bufp++;
  185. +             else
  186. +                 {
  187. +             *target_bufp++ = *local_bufp++;
  188. +             result_size++;
  189. +             }
  190. +     }
  191. +   return(result_size);
  192. + }
  193. + 
  194. + /* the following dingus is used in place of some calls to bcopy,
  195. +    to ensure that backslashes get properly slashified when getting
  196. +    shoved into strings.  Note that it returns the new pointer!!
  197. +    There ought to be a better way... */
  198. + 
  199. + U_CHAR * slashifying_bcopy(from_buf, to_buf, nbytes)
  200. + U_CHAR * from_buf, * to_buf;
  201. + int nbytes;
  202. + {
  203. +   for ( ; nbytes > 0 ; )
  204. +     {
  205. +     if(*from_buf == '\\')
  206. +         *to_buf++ = '\\';
  207. +     *to_buf++ = *from_buf++;
  208. +     nbytes--;
  209. +     }
  210. +   return(to_buf);
  211. + }
  212. + 
  213. + #endif        /* atarist */
  214.   
  215. + #ifndef atarist
  216.   /* Handler for SIGPIPE.  */
  217.   
  218.   static void
  219. ***************
  220. *** 515,520 ****
  221. --- 633,639 ----
  222.   {
  223.     fatal ("output pipe has been closed");
  224.   }
  225. + #endif
  226.   
  227.   int
  228.   main (argc, argv)
  229. ***************
  230. *** 540,545 ****
  231. --- 659,669 ----
  232.     /* Target-name to write with the dependency information.  */
  233.     char *deps_target = 0;
  234.   
  235. + #ifdef atarist
  236. + /* turn this on if you are going to set the TOS 1.4 dont clear heap flag */
  237. + /*  _malloczero(1); */     /* zero mallocs by default */
  238. + #endif  
  239. + 
  240.   #ifdef RLIMIT_STACK
  241.     /* Get rid of any avoidable limit on stack size.  */
  242.     {
  243. ***************
  244. *** 588,600 ****
  245. --- 712,730 ----
  246.     cplusplus = 1;
  247.   #endif
  248.   
  249. + #ifndef atarist
  250.     signal (SIGPIPE, pipe_closed);
  251. + #endif  
  252.   
  253.   #ifndef VMS
  254.     max_include_len
  255. + #ifdef atarist
  256. +     =    sizeof ("/usr/include/CC");
  257. + #else
  258.       = max (max (sizeof (GCC_INCLUDE_DIR),
  259.           sizeof (GPLUSPLUS_INCLUDE_DIR)),
  260.          sizeof ("/usr/include/CC"));
  261. + #endif
  262.   #else /* VMS */
  263.     max_include_len
  264.       = sizeof("SYS$SYSROOT:[SYSLIB.]");
  265. ***************
  266. *** 604,609 ****
  267. --- 734,759 ----
  268.     bzero (pend_defs, argc * sizeof (char *));
  269.     bzero (pend_undefs, argc * sizeof (char *));
  270.   
  271. + #ifdef atarist
  272. + /* see if we have an indication of where the GNU library directory is */
  273. +   {
  274. +     char * gnulib = (char * ) getenv("GNUINC");
  275. +     struct file_name_list * gnulib_dir;
  276. + 
  277. +     if(!gnulib) gnulib = (char *) getenv("GNULIB"); /* try GNULIB */
  278. +     if (gnulib)
  279. +     {
  280. +     gnulib_dir = (struct file_name_list * ) 
  281. +         xmalloc(sizeof(struct file_name_list));
  282. +     gnulib_dir->fname = xmalloc(strlen(gnulib) + 1);
  283. +     strcpy(gnulib_dir->fname, gnulib);
  284. + /* cons it onto the front of the defaults. */
  285. +     gnulib_dir->next = include_defaults;
  286. +     include_defaults = gnulib_dir;
  287. +     }
  288. +   }
  289. + #endif
  290. + 
  291.     /* Process switches and find input file name.  */
  292.   
  293.     for (i = 1; i < argc; i++) {
  294. ***************
  295. *** 968,974 ****
  296. --- 1118,1128 ----
  297.       fp->buf = (U_CHAR *) xmalloc (bsize + 2);
  298.       bufp = fp->buf;
  299.       for (;;) {
  300. + #ifdef atarist
  301. +       cnt = eunuchs_read (f, bufp, bsize - size);
  302. + #else
  303.         cnt = read (f, bufp, bsize - size);
  304. + #endif
  305.         if (cnt < 0) goto perror;    /* error! */
  306.         if (cnt == 0) break;    /* End of file */
  307.         size += cnt;
  308. ***************
  309. *** 988,994 ****
  310. --- 1142,1152 ----
  311.       fp->buf = (U_CHAR *) xmalloc (st_size + 2);
  312.   
  313.       while (st_size > 0) {
  314. + #ifdef atarist
  315. +       i = eunuchs_read (f, fp->buf + fp->length, st_size);
  316. + #else
  317.         i = read (f, fp->buf + fp->length, st_size);
  318. + #endif
  319.         if (i <= 0) {
  320.           if (i == 0) break;
  321.       goto perror;
  322. ***************
  323. *** 1048,1053 ****
  324. --- 1206,1214 ----
  325.     if (ferror (stdout))
  326.       fatal ("I/O error on output");
  327.   
  328. + #ifdef atarist
  329. +   close(fileno(stdout));        /* this shouldn't be necessary */
  330. + #endif
  331.     if (errors)
  332.       exit (FATAL_EXIT_CODE);
  333.     exit (SUCCESS_EXIT_CODE);
  334. ***************
  335. *** 2333,2340 ****
  336. --- 2494,2510 ----
  337.   
  338.         if (string)
  339.       {
  340. + #ifndef atarist
  341.         buf = (char *) alloca (3 + strlen (string));
  342.         sprintf (buf, "\"%s\"", string);
  343. + #else
  344. +           buf = (char *) alloca (16 + strlen (string));
  345. +           {
  346. +           char *tbuf = (char *) alloca (16 + strlen (string));
  347. +           (void) slashifying_bcopy(string, tbuf, strlen(string)+1);
  348. +           sprintf (buf, "\"%s\"", tbuf);
  349. +           }
  350. + #endif /* atarist */
  351.       }
  352.         else
  353.       buf = "\"\"";
  354. ***************
  355. *** 2485,2490 ****
  356. --- 2655,2664 ----
  357.              and put it in front of the search list.  */
  358.           dsp[0].next = stackp;
  359.           stackp = dsp;
  360. + #ifdef atarist
  361. +           if((ep = rindex (nam, '\\')) == NULL)
  362. +           ep = rindex(nam, '/');    /* allow both */
  363. + #else
  364.   #ifndef VMS
  365.           ep = rindex (nam, '/');
  366.   #else                /* VMS */
  367. ***************
  368. *** 2493,2498 ****
  369. --- 2667,2673 ----
  370.           if (ep == NULL) ep = rindex (nam, ':');
  371.           if (ep != NULL) ep++;
  372.   #endif                /* VMS */
  373. + #endif /* atarist */
  374.           if (ep != NULL) {
  375.             n = ep - nam;
  376.             dsp[0].fname = (char *) alloca (n + 1);
  377. ***************
  378. *** 2543,2549 ****
  379. --- 2718,2728 ----
  380.   
  381.     /* If specified file name is absolute, just open it.  */
  382.   
  383. + #ifdef atarist
  384. +   if ((*fbeg == '\\') || (*fbeg == '/')) {
  385. + #else
  386.     if (*fbeg == '/') {
  387. + #endif
  388.       strncpy (fname, fbeg, flen);
  389.       fname[flen] = 0;
  390.       f = open (fname, O_RDONLY, 0666);
  391. ***************
  392. *** 2554,2560 ****
  393. --- 2733,2743 ----
  394.       for (; stackp; stackp = stackp->next) {
  395.         if (stackp->fname) {
  396.       strcpy (fname, stackp->fname);
  397. + #ifdef atarist
  398. +     strcat (fname, "\\");
  399. + #else
  400.       strcat (fname, "/");
  401. + #endif
  402.       fname[strlen (fname) + flen] = 0;
  403.         } else {
  404.       fname[0] = 0;
  405. ***************
  406. *** 2674,2680 ****
  407.       /* Read the file contents, knowing that st_size is an upper bound
  408.          on the number of bytes we can read.  */
  409.       while (st_size > 0) {
  410. !       i = read (f, fp->buf + fp->length, st_size);
  411.         if (i <= 0) {
  412.       if (i == 0) break;
  413.       goto nope;
  414. --- 2857,2867 ----
  415.       /* Read the file contents, knowing that st_size is an upper bound
  416.          on the number of bytes we can read.  */
  417.       while (st_size > 0) {
  418. ! #ifdef atarist
  419. !     i = eunuchs_read (f, fp->buf + fp->length, st_size);
  420. ! #else
  421. !     i = read (f, fp->buf + fp->length, st_size);
  422. ! #endif
  423.         if (i <= 0) {
  424.       if (i == 0) break;
  425.       goto nope;
  426. ***************
  427. *** 2697,2703 ****
  428. --- 2884,2894 ----
  429.       bufp = basep;
  430.   
  431.       for (;;) {
  432. + #ifdef atarist
  433. +     i = eunuchs_read (f, bufp, bsize - st_size);
  434. + #else
  435.         i = read (f, bufp, bsize - st_size);
  436. + #endif
  437.         if (i < 0)
  438.       goto nope;      /* error! */
  439.         if (i == 0)
  440. ***************
  441. *** 4067,4074 ****
  442. --- 4258,4269 ----
  443.     check_expand (op, len + 1);
  444.     if (op->bufp > op->buf && op->bufp[-1] != '\n')
  445.       *op->bufp++ = '\n';
  446. + #ifdef atarist
  447. +   op->bufp = slashifying_bcopy (line_cmd_buf, op->bufp, len);
  448. + #else
  449.     bcopy (line_cmd_buf, op->bufp, len);
  450.     op->bufp += len;
  451. + #endif
  452.     op->lineno = ip->lineno;
  453.   }
  454.   
  455. ***************
  456. *** 4725,4731 ****
  457. --- 4920,4930 ----
  458.     if (ip != NULL)
  459.       fprintf (stderr, "%s:%d: ", ip->fname, ip->lineno);
  460.   
  461. + #ifdef atarist
  462. +   if ((errno > sys_nerr) && (errno < 0))
  463. + #else
  464.     if (errno < sys_nerr)
  465. + #endif
  466.       fprintf (stderr, "%s: %s\n", name, sys_errlist[errno]);
  467.     else
  468.       fprintf (stderr, "%s: undocumented I/O error\n", name);
  469. ***************
  470. *** 5251,5256 ****
  471. --- 5450,5456 ----
  472.     deps_buffer[deps_size] = 0;
  473.   }
  474.   
  475. + #if (!(defined(atarist) || defined(atariminix) || defined(CROSSATARI)))
  476.   #ifndef BSD
  477.   #ifndef BSTRING
  478.   
  479. ***************
  480. *** 5318,5324 ****
  481.   }
  482.   #endif /* not BSTRING */
  483.   #endif /* not BSD */
  484. ! 
  485.   
  486.   void
  487.   fatal (str, arg)
  488. --- 5518,5524 ----
  489.   }
  490.   #endif /* not BSTRING */
  491.   #endif /* not BSD */
  492. ! #endif /* not ATARI */
  493.   
  494.   void
  495.   fatal (str, arg)
  496. ***************
  497. *** 5347,5353 ****
  498. --- 5547,5557 ----
  499.     extern char *sys_errlist[];
  500.   
  501.     fprintf (stderr, "%s: ", progname);
  502. + #ifdef atarist
  503. +   if ((errno > sys_nerr) && (errno < 0))
  504. + #else
  505.     if (errno < sys_nerr)
  506. + #endif
  507.       fprintf (stderr, "%s: %s\n", name, sys_errlist[errno]);
  508.     else
  509.       fprintf (stderr, "%s: undocumented I/O error\n", name);
  510. *** ../../../Gnu/gcc-1.36/combine.c    Fri Sep 15 00:40:17 1989
  511. --- combine.c    Wed Sep 27 12:28:46 1989
  512. ***************
  513. *** 814,820 ****
  514. --- 814,824 ----
  515.     register char *fmt;
  516.     register int len, i;
  517.     register enum rtx_code code;
  518. + #if (defined(atarist) || defined(atariminix))
  519. +   short was_replaced[2];    /* 'char' confuses GAS 1.14... */
  520. + #else
  521.     char was_replaced[2];
  522. + #endif
  523.   
  524.   #define SUBST(INTO, NEWVAL)  \
  525.    do { if (undobuf.num_undo < MAX_UNDO)                    \
  526. *** ../../../Gnu/gcc-1.36/gcc.c    Sun Sep 17 16:51:58 1989
  527. --- gcc.c    Sat Sep 30 20:51:53 1989
  528. ***************
  529. *** 117,122 ****
  530. --- 117,131 ----
  531.   
  532.   */
  533.   
  534. + #ifdef CROSSATARI
  535. + #ifdef atarist
  536. + #undef atarist
  537. + #endif
  538. + #ifdef atariminix
  539. + #undef atariminix
  540. + #endif
  541. + #endif
  542. +   
  543.   #include <stdio.h>
  544.   #include <sys/types.h>
  545.   #include <signal.h>
  546. ***************
  547. *** 126,138 ****
  548.   #include "obstack.h"
  549.   #include "gvarargs.h"
  550.   
  551. ! #ifdef USG
  552.   #define R_OK 4
  553.   #define W_OK 2
  554.   #define X_OK 1
  555.   #define vfork fork
  556.   #endif /* USG */
  557.   
  558.   #define obstack_chunk_alloc xmalloc
  559.   #define obstack_chunk_free free
  560.   extern int xmalloc ();
  561. --- 135,154 ----
  562.   #include "obstack.h"
  563.   #include "gvarargs.h"
  564.   
  565. ! #if (defined(USG) || defined(atariminix))
  566.   #define R_OK 4
  567.   #define W_OK 2
  568.   #define X_OK 1
  569.   #define vfork fork
  570.   #endif /* USG */
  571.   
  572. + #ifdef atarist
  573. + #include <osbind.h>
  574. + #include <ctype.h>
  575. + long _stksize = 8192;
  576. + extern char *getenv();
  577. + #endif
  578. + 
  579.   #define obstack_chunk_alloc xmalloc
  580.   #define obstack_chunk_free free
  581.   extern int xmalloc ();
  582. ***************
  583. *** 232,239 ****
  584.   {
  585.     {".c",
  586.      "cpp %{nostdinc} %{C} %{v} %{D*} %{U*} %{I*} %{M*} %{i*} %{trigraphs} -undef \
  587. !         -D__GNUC__ %{ansi:-trigraphs -$ -D__STRICT_ANSI__} %{!ansi:%p} %P\
  588. !         %c %{O:-D__OPTIMIZE__} %{traditional} %{pedantic}\
  589.       %{Wcomment*} %{Wtrigraphs} %{Wall} %C\
  590.           %i %{!M*:%{!E:%{!pipe:%g.cpp}}}%{E:%{o*}}%{M*:%{o*}} |\n\
  591.       %{!M*:%{!E:cc1 %{!pipe:%g.cpp} %1 \
  592. --- 248,256 ----
  593.   {
  594.     {".c",
  595.      "cpp %{nostdinc} %{C} %{v} %{D*} %{U*} %{I*} %{M*} %{i*} %{trigraphs} -undef \
  596. !         -D__GNUC__ %{ansi:-trigraphs -$ -D__STRICT_ANSI__} %{!ansi:%p}\
  597. !         %c %{O:-D__OPTIMIZE__} %{mshort:-D__MSHORT__} %{traditional}\
  598. !         %{pedantic}\
  599.       %{Wcomment*} %{Wtrigraphs} %{Wall} %C\
  600.           %i %{!M*:%{!E:%{!pipe:%g.cpp}}}%{E:%{o*}}%{M*:%{o*}} |\n\
  601.       %{!M*:%{!E:cc1 %{!pipe:%g.cpp} %1 \
  602. ***************
  603. *** 247,254 ****
  604.                         %{!pipe:%g.s}\n }}}"},
  605.     {".cc",
  606.      "cpp -+ %{nostdinc} %{C} %{v} %{D*} %{U*} %{I*} %{M*} %{i*} \
  607. !         -undef -D__GNUC__ %p %P\
  608. !         %c %{O:-D__OPTIMIZE__} %{traditional} %{pedantic}\
  609.       %{Wcomment*} %{Wtrigraphs} %{Wall} %C\
  610.           %i %{!M*:%{!E:%{!pipe:%g.cpp}}}%{E:%{o*}}%{M*:%{o*}} |\n\
  611.       %{!M*:%{!E:cc1plus %{!pipe:%g.cpp} %1\
  612. --- 264,272 ----
  613.                         %{!pipe:%g.s}\n }}}"},
  614.     {".cc",
  615.      "cpp -+ %{nostdinc} %{C} %{v} %{D*} %{U*} %{I*} %{M*} %{i*} \
  616. !         -undef -D__GNUC__ %p\
  617. !         %c %{O:-D__OPTIMIZE__} %{mshort:-D__MSHORT__} %{traditional}\
  618. !         %{pedantic}\
  619.       %{Wcomment*} %{Wtrigraphs} %{Wall} %C\
  620.           %i %{!M*:%{!E:%{!pipe:%g.cpp}}}%{E:%{o*}}%{M*:%{o*}} |\n\
  621.       %{!M*:%{!E:cc1plus %{!pipe:%g.cpp} %1\
  622. ***************
  623. *** 272,279 ****
  624.               %{c:%{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%b.o} %i\n }"},
  625.     {".S",
  626.      "cpp %{nostdinc} %{C} %{v} %{D*} %{U*} %{I*} %{M*} %{trigraphs} \
  627. !         -undef -D__GNUC__ -$ %p %P\
  628. !         %c %{O:-D__OPTIMIZE__} %{traditional} %{pedantic}\
  629.       %{Wcomment*} %{Wtrigraphs} %{Wall} %C\
  630.           %i %{!M*:%{!E:%{!pipe:%g.s}}}%{E:%{o*}}%{M*:%{o*}} |\n\
  631.       %{!M*:%{!E:%{!S:as %{R} %{j} %{J} %{h} %{d2} %a \
  632. --- 290,298 ----
  633.               %{c:%{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%b.o} %i\n }"},
  634.     {".S",
  635.      "cpp %{nostdinc} %{C} %{v} %{D*} %{U*} %{I*} %{M*} %{trigraphs} \
  636. !         -undef -D__GNUC__ -$ %p\
  637. !         %c %{O:-D__OPTIMIZE__} %{mshort:-D__MSHORT__} %{traditional}\
  638. !         %{pedantic}\
  639.       %{Wcomment*} %{Wtrigraphs} %{Wall} %C\
  640.           %i %{!M*:%{!E:%{!pipe:%g.s}}}%{E:%{o*}}%{M*:%{o*}} |\n\
  641.       %{!M*:%{!E:%{!S:as %{R} %{j} %{J} %{h} %{d2} %a \
  642. ***************
  643. *** 284,293 ****
  644. --- 303,324 ----
  645.   };
  646.   
  647.   /* Here is the spec for running the linker, after compiling all files.  */
  648. + 
  649. + #if (defined(CROSSATARI) || defined(atarist) || defined(atariminix))
  650. +  
  651. +  char *link_spec = "%{!c:%{!M*:%{!E:%{!S:ld %{o*} %l\
  652. +  %{A} %{d} %{e*} %{N} %{n} %{r} %{s} %{S} %{T*} %{t} %{u*} %{X} %{x} %{z}\
  653. +  %{y*} %{!nostdlib:%S} \
  654. +  %{L*} %o %{!nostdlib:%s %L}\n }}}}";
  655. + 
  656. + #else
  657. + 
  658.   char *link_spec = "%{!c:%{!M*:%{!E:%{!S:ld %{o*} %l\
  659.    %{A} %{d} %{e*} %{N} %{n} %{r} %{s} %{S} %{T*} %{t} %{u*} %{X} %{x} %{z}\
  660.    %{y*} %{!A:%{!nostdlib:%S}} \
  661.    %{L*} %o %{!nostdlib:gnulib%s %{g:-lg} %L}\n }}}}";
  662. + 
  663. + #endif /* not atari */
  664.   
  665.   /* Accumulate a command (program name and args), and run it.  */
  666.   
  667. ***************
  668. *** 327,348 ****
  669.   
  670.   /* Suffix to attach to directories searched for commands.  */
  671.   
  672. ! char *machine_suffix = 0;
  673.   
  674.   /* Default prefixes to attach to command names.  */
  675.   
  676.   #ifndef STANDARD_EXEC_PREFIX
  677. ! #define STANDARD_EXEC_PREFIX "/usr/local/lib/gcc-"
  678.   #endif /* !defined STANDARD_EXEC_PREFIX */
  679.   
  680.   char *standard_exec_prefix = STANDARD_EXEC_PREFIX;
  681.   char *standard_exec_prefix_1 = "/usr/lib/gcc-";
  682.   
  683. ! #ifndef STANDARD_STARTFILE_PREFIX
  684. ! #define STANDARD_STARTFILE_PREFIX "/usr/local/lib/"
  685. ! #endif /* !defined STANDARD_STARTFILE_PREFIX */
  686.   
  687. - char *standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
  688.   char *standard_startfile_prefix_1 = "/lib/";
  689.   char *standard_startfile_prefix_2 = "/usr/lib/";
  690.   
  691. --- 358,403 ----
  692.   
  693.   /* Suffix to attach to directories searched for commands.  */
  694.   
  695. ! #ifndef atarist
  696. !   char *machine_suffix = 0;
  697. ! #else
  698. !   char *machine_suffix = ".ttp";
  699. ! #endif
  700.   
  701.   /* Default prefixes to attach to command names.  */
  702.   
  703.   #ifndef STANDARD_EXEC_PREFIX
  704. ! #  ifdef CROSSATARI
  705. ! #    ifdef MINIX
  706. ! #      define STANDARD_EXEC_PREFIX "/dsrg/bammi/cross-minix/lib/gcc-"
  707. ! #    else
  708. ! #      define STANDARD_EXEC_PREFIX "/dsrg/bammi/cross-gcc/lib/gcc-"
  709. ! #    endif /* MINIX */
  710. ! #  else /* not cross compiler */
  711. ! #    define STANDARD_EXEC_PREFIX "/usr/local/lib/gcc-"
  712. ! #  endif /* CROSSATARI */
  713.   #endif /* !defined STANDARD_EXEC_PREFIX */
  714.   
  715.   char *standard_exec_prefix = STANDARD_EXEC_PREFIX;
  716.   char *standard_exec_prefix_1 = "/usr/lib/gcc-";
  717.   
  718. ! #ifdef CROSSATARI
  719. ! #  ifdef MINIX
  720. !     char *standard_startfile_prefix = "/dsrg/bammi/cross-minix/lib/";
  721. ! #  else
  722. !     char *standard_startfile_prefix = "/dsrg/bammi/cross-gcc/lib/";
  723. ! #  endif
  724. ! #else
  725. ! #  ifdef atariminix
  726. !     char *standard_startfile_prefix = "/usr/local/lib/";
  727. ! #  else
  728. ! #    ifndef STANDARD_STARTFILE_PREFIX
  729. ! #      define STANDARD_STARTFILE_PREFIX "/usr/local/lib/"
  730. ! #    endif /* !defined STANDARD_STARTFILE_PREFIX */
  731. !      char *standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
  732. ! #  endif
  733. ! #endif
  734.   
  735.   char *standard_startfile_prefix_1 = "/lib/";
  736.   char *standard_startfile_prefix_2 = "/usr/lib/";
  737.   
  738. ***************
  739. *** 520,527 ****
  740.   choose_temp_base ()
  741.   {
  742.     extern char *getenv ();
  743. -   char *base = getenv ("TMPDIR");
  744.     int len;
  745.   
  746.     if (base == (char *)0)
  747.       {
  748. --- 575,588 ----
  749.   choose_temp_base ()
  750.   {
  751.     extern char *getenv ();
  752.     int len;
  753. + #if (!(defined(atarist) || defined(atariminix)))
  754. +   char *base = getenv ("TMPDIR");
  755. + #else
  756. +   char *base = getenv ("TEMP");
  757. +   if(base == (char *)0)
  758. +       base = getenv("TMPDIR");
  759. + #endif
  760.   
  761.     if (base == (char *)0)
  762.       {
  763. ***************
  764. *** 579,586 ****
  765.         if (machine_suffix)
  766.       {
  767.         strcpy (temp, user_exec_prefix);
  768. -       strcat (temp, machine_suffix);
  769.         strcat (temp, prog);
  770.         win = (access (temp, X_OK) == 0);
  771.       }
  772.         if (!win)
  773. --- 640,647 ----
  774.         if (machine_suffix)
  775.       {
  776.         strcpy (temp, user_exec_prefix);
  777.         strcat (temp, prog);
  778. +       strcat (temp, machine_suffix);
  779.         win = (access (temp, X_OK) == 0);
  780.       }
  781.         if (!win)
  782. ***************
  783. *** 596,603 ****
  784.         if (machine_suffix)
  785.       {
  786.         strcpy (temp, env_exec_prefix);
  787. -       strcat (temp, machine_suffix);
  788.         strcat (temp, prog);
  789.         win = (access (temp, X_OK) == 0);
  790.       }
  791.         if (!win)
  792. --- 657,664 ----
  793.         if (machine_suffix)
  794.       {
  795.         strcpy (temp, env_exec_prefix);
  796.         strcat (temp, prog);
  797. +       strcat (temp, machine_suffix);
  798.         win = (access (temp, X_OK) == 0);
  799.       }
  800.         if (!win)
  801. ***************
  802. *** 613,620 ****
  803.         if (machine_suffix)
  804.       {
  805.         strcpy (temp, standard_exec_prefix);
  806. -       strcat (temp, machine_suffix);
  807.         strcat (temp, prog);
  808.         win = (access (temp, X_OK) == 0);
  809.       }
  810.         if (!win)
  811. --- 674,681 ----
  812.         if (machine_suffix)
  813.       {
  814.         strcpy (temp, standard_exec_prefix);
  815.         strcat (temp, prog);
  816. +       strcat (temp, machine_suffix);
  817.         win = (access (temp, X_OK) == 0);
  818.       }
  819.         if (!win)
  820. ***************
  821. *** 630,637 ****
  822.         if (machine_suffix)
  823.       {
  824.         strcpy (temp, standard_exec_prefix_1);
  825. -       strcat (temp, machine_suffix);
  826.         strcat (temp, prog);
  827.         win = (access (temp, X_OK) == 0);
  828.       }
  829.         if (!win)
  830. --- 691,698 ----
  831.         if (machine_suffix)
  832.       {
  833.         strcpy (temp, standard_exec_prefix_1);
  834.         strcat (temp, prog);
  835. +       strcat (temp, machine_suffix);
  836.         win = (access (temp, X_OK) == 0);
  837.       }
  838.         if (!win)
  839. ***************
  840. *** 671,676 ****
  841. --- 732,738 ----
  842.      NOT_LAST is nonzero if this is not the last subcommand
  843.      (i.e. its output should be piped to the next one.)  */
  844.   
  845. + #ifndef atarist
  846.   static int
  847.   pexecute (func, program, argv, not_last)
  848.        char *program;
  849. ***************
  850. *** 741,746 ****
  851. --- 803,809 ----
  852.         return pid;
  853.       }
  854.   }
  855. + #endif /* atarist */
  856.   
  857.   /* Execute the command specified by the arguments on the current line of spec.
  858.      When using pipes, this includes several piped-together commands
  859. ***************
  860. *** 758,773 ****
  861.       {
  862.         char *prog;        /* program name.  */
  863.         char **argv;        /* vector of args.  */
  864.         int pid;            /* pid of process for this command.  */
  865.       };
  866.   
  867.     struct command *commands;    /* each command buffer with above info.  */
  868.   
  869.     /* Count # of piped commands.  */
  870.     for (n_commands = 1, i = 0; i < argbuf_index; i++)
  871.       if (strcmp (argbuf[i], "|") == 0)
  872. !       n_commands++;
  873. ! 
  874.     /* Get storage for each command.  */
  875.     commands
  876.       = (struct command *) alloca (n_commands * sizeof (struct command));
  877. --- 821,842 ----
  878.       {
  879.         char *prog;        /* program name.  */
  880.         char **argv;        /* vector of args.  */
  881. + #ifndef atarist
  882.         int pid;            /* pid of process for this command.  */
  883. + #endif
  884.       };
  885.   
  886.     struct command *commands;    /* each command buffer with above info.  */
  887.   
  888. + #ifndef atarist
  889.     /* Count # of piped commands.  */
  890.     for (n_commands = 1, i = 0; i < argbuf_index; i++)
  891.       if (strcmp (argbuf[i], "|") == 0)
  892. !      n_commands++;
  893. ! #else
  894. !   n_commands = 1;
  895. ! #endif
  896. !   
  897.     /* Get storage for each command.  */
  898.     commands
  899.       = (struct command *) alloca (n_commands * sizeof (struct command));
  900. ***************
  901. *** 782,787 ****
  902. --- 851,857 ----
  903.     if (string)
  904.       commands[0].argv[0] = string;
  905.   
  906. + #ifndef atarist
  907.     for (n_commands = 1, i = 0; i < argbuf_index; i++)
  908.       if (strcmp (argbuf[i], "|") == 0)
  909.         {                /* each command.  */
  910. ***************
  911. *** 793,799 ****
  912.         commands[n_commands].argv[0] = string;
  913.       n_commands++;
  914.         }
  915. ! 
  916.     argbuf[argbuf_index] = 0;
  917.   
  918.     /* If -v, print what we are about to do, and maybe query.  */
  919. --- 863,872 ----
  920.         commands[n_commands].argv[0] = string;
  921.       n_commands++;
  922.         }
  923. ! #else
  924. !   n_commands = 1;
  925. ! #endif
  926. !   
  927.     argbuf[argbuf_index] = 0;
  928.   
  929.     /* If -v, print what we are about to do, and maybe query.  */
  930. ***************
  931. *** 808,818 ****
  932.         for (j = commands[i].argv; *j; j++)
  933.           fprintf (stderr, " %s", *j);
  934.   
  935.         /* Print a pipe symbol after all but the last command.  */
  936.         if (i + 1 != n_commands)
  937.           fprintf (stderr, " |");
  938.         fprintf (stderr, "\n");
  939. !     }
  940.         fflush (stderr);
  941.   #ifdef DEBUG
  942.         fprintf (stderr, "\nGo ahead? (y or n) ");
  943. --- 881,893 ----
  944.         for (j = commands[i].argv; *j; j++)
  945.           fprintf (stderr, " %s", *j);
  946.   
  947. + #ifndef atarist
  948.         /* Print a pipe symbol after all but the last command.  */
  949.         if (i + 1 != n_commands)
  950.           fprintf (stderr, " |");
  951. + #endif
  952.         fprintf (stderr, "\n");
  953. !       }
  954.         fflush (stderr);
  955.   #ifdef DEBUG
  956.         fprintf (stderr, "\nGo ahead? (y or n) ");
  957. ***************
  958. *** 825,842 ****
  959. --- 900,926 ----
  960.   #endif /* DEBUG */
  961.       }
  962.   
  963. + #ifndef atarist
  964.     /* Run each piped subprocess.  */
  965.   
  966.     last_pipe_input = STDIN_FILE_NO;
  967.     for (i = 0; i < n_commands; i++)
  968.       {
  969. + #ifndef atariminix
  970.         extern int execv(), execvp();
  971.         char *string = commands[i].argv[0];
  972.   
  973.         commands[i].pid = pexecute ((string != commands[i].prog ? execv : execvp),
  974.                     string, commands[i].argv,
  975.                     i + 1 < n_commands);
  976. + #else
  977. +       extern int execv();
  978. +       char *string = commands[i].argv[0];
  979.   
  980. +       commands[i].pid = pexecute (execv,
  981. +                   string, commands[i].argv,
  982. +                   i + 1 < n_commands);
  983. + #endif
  984.         if (string != commands[i].prog)
  985.       free (string);
  986.       }
  987. ***************
  988. *** 875,881 ****
  989. --- 959,982 ----
  990.         }
  991.       return ret_code;
  992.     }
  993. + #else  /* atarist */
  994. +  {
  995. +      register int iii;
  996. +      char **j;
  997. + 
  998. +      execution_count++;
  999. +      for (i = 0; i < n_commands ; i++)
  1000. +      {
  1001. +      j = commands[i].argv;
  1002. +          iii = spawnve(0, j[0], j, NULL);
  1003. +      if(iii != 0)
  1004. +          return -1;
  1005. +      }
  1006. +      return 0;
  1007. +  }
  1008. + #endif /* atarist */  
  1009.   }
  1010. + 
  1011.   
  1012.   /* Find all the switches given to us
  1013.      and make a vector describing them.
  1014. ***************
  1015. *** 1032,1037 ****
  1016. --- 1133,1148 ----
  1017.      search dirs for it.  */
  1018.   int this_is_library_file;
  1019.   
  1020. + #ifdef atarist
  1021. + /* I don't know why this is necessary.  Recursive calls to do_spec_1
  1022. +    end up ignoring the error code from calls to execute().  That causes
  1023. +    do_spec to get a 0 return value, and do_spec_1("\n"), which causes the
  1024. +    command to get executed again.
  1025. + */
  1026. + int execute_return_error = 0;
  1027. + #endif
  1028. + 
  1029. + 
  1030.   /* Process the spec SPEC and run the commands specified therein.
  1031.      Returns 0 if the spec is successfully processed; -1 if failed.  */
  1032.   
  1033. ***************
  1034. *** 1051,1060 ****
  1035. --- 1162,1180 ----
  1036.   
  1037.     /* Force out any unfinished command.
  1038.        If -pipe, this forces out the last command if it ended in `|'.  */
  1039. + #ifdef atarist
  1040. +   if (!value && execute_return_error)
  1041. +     {
  1042. +     value = execute_return_error;
  1043. +     execute_return_error = 0;
  1044. +     }
  1045. + #endif
  1046.     if (value == 0)
  1047.       {
  1048. + #ifndef atarist
  1049.         if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
  1050.       argbuf_index--;
  1051. + #endif
  1052.   
  1053.         if (argbuf_index > 0)
  1054.       value = execute ();
  1055. ***************
  1056. *** 1083,1094 ****
  1057. --- 1203,1248 ----
  1058.     register char *p = spec;
  1059.     register int c;
  1060.     char *string;
  1061. +   extern char *find_file();    /* ++jrb */
  1062.   
  1063.     while (c = *p++)
  1064.       /* If substituting a switch, treat all chars like letters.
  1065.          Otherwise, NL, SPC, TAB and % are special.  */
  1066.       switch (inswitch ? 'a' : c)
  1067.         {
  1068. + #ifdef atarist
  1069. + /* this stuff added by jrd.  if see '$', expect name of env var, delimited
  1070. +    by '$'.  Find it's value, and subst it in.
  1071. + 
  1072. +    modified by ERS to only collect things that look like names; this
  1073. +    saves e.g. the -$ arg. to cpp from getting munged */
  1074. + 
  1075. +       case '$':
  1076. +       {
  1077. +     char varname[32];        /* should be enough */
  1078. +     char * value;            /* deciphered value string */
  1079. +     int i;
  1080. + 
  1081. +     for (i = 0 ; ((c = *p) != '$') && isalnum(c) && i < 31 ; i++, p++)
  1082. +         varname[i] = c;
  1083. +     varname[i] = '\0';
  1084. +     if (strlen(varname) > 0) /* ++jrb fix */
  1085. +     {
  1086. +                  ++p;    /* skip trailing '$' */
  1087. +         value = (char * )getenv(varname); /* ++jrb fix */
  1088. +         if (value)
  1089. +             do_spec_1(value, 0);
  1090. +             else
  1091. +             do_spec_1(".", 0);    /* a compleat kludge... */
  1092. +     }
  1093. +         else
  1094. +         {
  1095. +              obstack_1grow(&obstack, '$');
  1096. +              arg_going = 1;
  1097. +         }
  1098. +       }
  1099. +      break;
  1100. + #endif /* atarist */
  1101.         case '\n':
  1102.       /* End of line: finish any pending argument,
  1103.          then run the pending command if one has been started.  */
  1104. ***************
  1105. *** 1126,1131 ****
  1106. --- 1280,1289 ----
  1107.       if (argbuf_index > 0)
  1108.         {
  1109.           int value = execute ();
  1110. + #ifdef atarist
  1111. +         if (!execute_return_error)
  1112. +             execute_return_error = value;
  1113. + #endif
  1114.           if (value)
  1115.             return value;
  1116.         }
  1117. ***************
  1118. *** 1312,1317 ****
  1119. --- 1470,1479 ----
  1120.           break;
  1121.   
  1122.         default:
  1123. + #ifdef atarist
  1124. +         fprintf(stderr, "Bogus char '%c' found at pos %d of spec '%s'\n",
  1125. +         c, (p - spec - 1), spec);
  1126. + #endif
  1127.           abort ();
  1128.         }
  1129.       break;
  1130. ***************
  1131. *** 1342,1355 ****
  1132.          This is used in %{|!pipe:...}.  */
  1133.       pipe = 1, ++p;
  1134.   
  1135. !   if (*p == '!')
  1136.       /* A `!' after the open-brace negates the condition:
  1137.          succeed if the specified switch is not present.  */
  1138.       negate = 1, ++p;
  1139.   
  1140. !   filter = p;
  1141. !   while (*p != ':' && *p != '}') p++;
  1142. !   if (*p != '}')
  1143.       {
  1144.         register int count = 1;
  1145.         q = p + 1;
  1146. --- 1504,1517 ----
  1147.          This is used in %{|!pipe:...}.  */
  1148.       pipe = 1, ++p;
  1149.   
  1150. !    if (*p == '!')
  1151.       /* A `!' after the open-brace negates the condition:
  1152.          succeed if the specified switch is not present.  */
  1153.       negate = 1, ++p;
  1154.   
  1155. !     filter = p;
  1156. !     while (*p != ':' && *p != '}') p++;
  1157. !     if (*p != '}')
  1158.       {
  1159.         register int count = 1;
  1160.         q = p + 1;
  1161. ***************
  1162. *** 1425,1431 ****
  1163.           return 0;
  1164.           }
  1165.       }
  1166. !       else if (pipe)
  1167.       {
  1168.         /* Here if a %{|...} conditional fails: output a minus sign,
  1169.            which means "standard output" or "standard input".  */
  1170. --- 1587,1593 ----
  1171.           return 0;
  1172.           }
  1173.       }
  1174. !         else if (pipe)
  1175.       {
  1176.         /* Here if a %{|...} conditional fails: output a minus sign,
  1177.            which means "standard output" or "standard input".  */
  1178. ***************
  1179. *** 1496,1503 ****
  1180.         if (machine_suffix)
  1181.       {
  1182.         strcpy (temp, user_exec_prefix);
  1183. -       strcat (temp, machine_suffix);
  1184.         strcat (temp, name);
  1185.         win = (access (temp, R_OK) == 0);
  1186.       }
  1187.         if (!win)
  1188. --- 1658,1665 ----
  1189.         if (machine_suffix)
  1190.       {
  1191.         strcpy (temp, user_exec_prefix);
  1192.         strcat (temp, name);
  1193. +       strcat (temp, machine_suffix);
  1194.         win = (access (temp, R_OK) == 0);
  1195.       }
  1196.         if (!win)
  1197. ***************
  1198. *** 1513,1520 ****
  1199.         if (machine_suffix)
  1200.       {
  1201.         strcpy (temp, env_exec_prefix);
  1202. -       strcat (temp, machine_suffix);
  1203.         strcat (temp, name);
  1204.         win = (access (temp, R_OK) == 0);
  1205.       }
  1206.         if (!win)
  1207. --- 1675,1682 ----
  1208.         if (machine_suffix)
  1209.       {
  1210.         strcpy (temp, env_exec_prefix);
  1211.         strcat (temp, name);
  1212. +       strcat (temp, machine_suffix);
  1213.         win = (access (temp, R_OK) == 0);
  1214.       }
  1215.         if (!win)
  1216. ***************
  1217. *** 1530,1537 ****
  1218.         if (machine_suffix)
  1219.       {
  1220.         strcpy (temp, standard_exec_prefix);
  1221. -       strcat (temp, machine_suffix);
  1222.         strcat (temp, name);
  1223.         win = (access (temp, R_OK) == 0);
  1224.       }
  1225.         if (!win)
  1226. --- 1692,1699 ----
  1227.         if (machine_suffix)
  1228.       {
  1229.         strcpy (temp, standard_exec_prefix);
  1230.         strcat (temp, name);
  1231. +       strcat (temp, machine_suffix);
  1232.         win = (access (temp, R_OK) == 0);
  1233.       }
  1234.         if (!win)
  1235. ***************
  1236. *** 1547,1554 ****
  1237.         if (machine_suffix)
  1238.       {
  1239.         strcpy (temp, standard_exec_prefix_1);
  1240. -       strcat (temp, machine_suffix);
  1241.         strcat (temp, name);
  1242.         win = (access (temp, R_OK) == 0);
  1243.       }
  1244.         if (!win)
  1245. --- 1709,1716 ----
  1246.         if (machine_suffix)
  1247.       {
  1248.         strcpy (temp, standard_exec_prefix_1);
  1249.         strcat (temp, name);
  1250. +       strcat (temp, machine_suffix);
  1251.         win = (access (temp, R_OK) == 0);
  1252.       }
  1253.         if (!win)
  1254. ***************
  1255. *** 1564,1571 ****
  1256.         if (machine_suffix)
  1257.       {
  1258.         strcpy (temp, standard_startfile_prefix);
  1259. -       strcat (temp, machine_suffix);
  1260.         strcat (temp, name);
  1261.         win = (access (temp, R_OK) == 0);
  1262.       }
  1263.         if (!win)
  1264. --- 1726,1733 ----
  1265.         if (machine_suffix)
  1266.       {
  1267.         strcpy (temp, standard_startfile_prefix);
  1268.         strcat (temp, name);
  1269. +       strcat (temp, machine_suffix);
  1270.         win = (access (temp, R_OK) == 0);
  1271.       }
  1272.         if (!win)
  1273. ***************
  1274. *** 1581,1588 ****
  1275.         if (machine_suffix)
  1276.       {
  1277.         strcpy (temp, standard_startfile_prefix_1);
  1278. -       strcat (temp, machine_suffix);
  1279.         strcat (temp, name);
  1280.         win = (access (temp, R_OK) == 0);
  1281.       }
  1282.         if (!win)
  1283. --- 1743,1750 ----
  1284.         if (machine_suffix)
  1285.       {
  1286.         strcpy (temp, standard_startfile_prefix_1);
  1287.         strcat (temp, name);
  1288. +       strcat (temp, machine_suffix);
  1289.         win = (access (temp, R_OK) == 0);
  1290.       }
  1291.         if (!win)
  1292. ***************
  1293. *** 1598,1605 ****
  1294.         if (machine_suffix)
  1295.       {
  1296.         strcpy (temp, standard_startfile_prefix_2);
  1297. -       strcat (temp, machine_suffix);
  1298.         strcat (temp, name);
  1299.         win = (access (temp, R_OK) == 0);
  1300.       }
  1301.         if (!win)
  1302. --- 1760,1767 ----
  1303.         if (machine_suffix)
  1304.       {
  1305.         strcpy (temp, standard_startfile_prefix_2);
  1306.         strcat (temp, name);
  1307. +       strcat (temp, machine_suffix);
  1308.         win = (access (temp, R_OK) == 0);
  1309.       }
  1310.         if (!win)
  1311. ***************
  1312. *** 1615,1622 ****
  1313.         if (machine_suffix)
  1314.       {
  1315.         strcpy (temp, "./");
  1316. -       strcat (temp, machine_suffix);
  1317.         strcat (temp, name);
  1318.         win = (access (temp, R_OK) == 0);
  1319.       }
  1320.         if (!win)
  1321. --- 1777,1784 ----
  1322.         if (machine_suffix)
  1323.       {
  1324.         strcpy (temp, "./");
  1325.         strcat (temp, name);
  1326. +       strcat (temp, machine_suffix);
  1327.         win = (access (temp, R_OK) == 0);
  1328.       }
  1329.         if (!win)
  1330. ***************
  1331. *** 1634,1639 ****
  1332. --- 1796,1802 ----
  1333.   
  1334.   /* On fatal signals, delete all the temporary files.  */
  1335.   
  1336. + #ifndef atarist
  1337.   void
  1338.   fatal_error (signum)
  1339.        int signum;
  1340. ***************
  1341. *** 1645,1650 ****
  1342. --- 1808,1814 ----
  1343.        so its normal effect occurs.  */
  1344.     kill (getpid (), signum);
  1345.   }
  1346. + #endif /* atarist */
  1347.   
  1348.   int
  1349.   main (argc, argv)
  1350. ***************
  1351. *** 1657,1670 ****
  1352. --- 1821,1842 ----
  1353.     int linker_was_run = 0;
  1354.     char *explicit_link_files;
  1355.   
  1356. + #ifdef atarist
  1357. + /* turn this on if you are going to set the TOS 1.4 dont clear heap flag */
  1358. + /*  _malloczero(1); */     /* zero mallocs by default */
  1359. +   programname = "gcc";
  1360. + #else  
  1361.     programname = argv[0];
  1362. + #endif
  1363.   
  1364. + #ifndef atarist
  1365.     if (signal (SIGINT, SIG_IGN) != SIG_IGN)
  1366.       signal (SIGINT, fatal_error);
  1367.     if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
  1368.       signal (SIGHUP, fatal_error);
  1369.     if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
  1370.       signal (SIGTERM, fatal_error);
  1371. + #endif
  1372.   
  1373.     argbuf_length = 10;
  1374.     argbuf = (char **) xmalloc (argbuf_length * sizeof (char *));
  1375. ***************
  1376. *** 1678,1683 ****
  1377. --- 1850,1865 ----
  1378.   
  1379.     process_command (argc, argv);
  1380.   
  1381. + #ifdef atarist
  1382. + /* if no default dir specified for executables, look for an env var
  1383. +    called 'GCCEXEC' and use that */
  1384. + 
  1385. +   if (!user_exec_prefix)
  1386. +       {
  1387. +     user_exec_prefix = getenv("GCCEXEC");
  1388. +     }
  1389. + #endif /* atarist */
  1390. + 
  1391.     if (vflag)
  1392.       {
  1393.         extern char *version_string;
  1394. ***************
  1395. *** 1730,1736 ****
  1396. --- 1912,1923 ----
  1397.   
  1398.             input_basename = input_filename;
  1399.             for (p = input_filename; *p; p++)
  1400. + #ifdef atarist
  1401. +         if (((*p == '/') || (*p == '\\')) && (*(p-1) != ':'))
  1402. +             /* allow both '\' and '/' with  our new lib */
  1403. + #else
  1404.           if (*p == '/')
  1405. + #endif
  1406.             input_basename = p + 1;
  1407.             basename_length = (input_filename_length - strlen (cp->suffix)
  1408.                    - (input_basename - input_filename));
  1409. ***************
  1410. *** 1852,1858 ****
  1411. --- 2039,2049 ----
  1412.     extern char *sys_errlist[];
  1413.     char *s;
  1414.   
  1415. + #ifdef atarist
  1416. +   if ((errno > sys_nerr) && (errno < 0))
  1417. + #else
  1418.     if (errno < sys_nerr)
  1419. + #endif
  1420.       s = concat ("%s: ", sys_errlist[errno], "");
  1421.     else
  1422.       s = "cannot open %s";
  1423. ***************
  1424. *** 1866,1872 ****
  1425. --- 2057,2067 ----
  1426.     extern char *sys_errlist[];
  1427.     char *s;
  1428.   
  1429. + #ifdef atarist
  1430. +   if ((errno > sys_nerr) && (errno < 0))
  1431. + #else
  1432.     if (errno < sys_nerr)
  1433. + #endif
  1434.       s = concat ("%s: ", sys_errlist[errno], "");
  1435.     else
  1436.       s = "cannot open %s";
  1437. ***************
  1438. *** 1880,1886 ****
  1439. --- 2075,2085 ----
  1440.     extern char *sys_errlist[];
  1441.     char *s;
  1442.   
  1443. + #ifdef atarist
  1444. +   if ((errno > sys_nerr) && (errno < 0))
  1445. + #else
  1446.     if (errno < sys_nerr)
  1447. + #endif
  1448.       s = concat ("installation problem, cannot exec %s: ",
  1449.           sys_errlist[errno], "");
  1450.     else
  1451. *** ../../../Gnu/gcc-1.36/toplev.c    Thu Sep  7 23:21:14 1989
  1452. --- toplev.c    Sat Sep 30 20:51:54 1989
  1453. ***************
  1454. *** 40,49 ****
  1455.   #include <time.h>   /* Correct for hpux at least.  Is it good on other USG?  */
  1456.   #else
  1457.   #ifndef VMS
  1458.   #include <sys/time.h>
  1459.   #include <sys/resource.h>
  1460.   #endif
  1461. - #endif
  1462.   
  1463.   #include "input.h"
  1464.   #include "tree.h"
  1465. --- 40,57 ----
  1466.   #include <time.h>   /* Correct for hpux at least.  Is it good on other USG?  */
  1467.   #else
  1468.   #ifndef VMS
  1469. + #if (!(defined(atarist) || defined(atariminix)))
  1470.   #include <sys/time.h>
  1471.   #include <sys/resource.h>
  1472. + #endif /* !(atarist || atariminix) */
  1473. + #endif /* !VMS */
  1474. + #endif /* USG */
  1475. + 
  1476. + #ifdef atariminix
  1477. + #include <sys/times.h>
  1478. + /* #include <minix/const.h>, avoid dragging this in */
  1479. + #define HZ 60    /* this is the only thing needed from minix/const.h */
  1480.   #endif
  1481.   
  1482.   #include "input.h"
  1483.   #include "tree.h"
  1484. ***************
  1485. *** 51,56 ****
  1486. --- 59,69 ----
  1487.   #include "rtl.h"
  1488.   #include "flags.h"
  1489.   
  1490. + #ifdef atarist
  1491. +   extern long _stksize = 128L * 1024L;        /* for 1M ST's */
  1492. +   /* extern long _stksize = 500000; */        /* enough to compile -O gas */
  1493. + #endif /* atarist */
  1494. + 
  1495.   extern int yydebug;
  1496.   
  1497.   extern FILE *finput;
  1498. ***************
  1499. *** 375,381 ****
  1500.   int
  1501.   gettime ()
  1502.   {
  1503. ! #ifdef USG
  1504.     struct tms tms;
  1505.   #else
  1506.   #ifndef VMS
  1507. --- 388,397 ----
  1508.   int
  1509.   gettime ()
  1510.   {
  1511. ! #ifdef atarist
  1512. !   long now;
  1513. ! #else
  1514. ! #if (defined(USG) || defined(atariminix))
  1515.     struct tms tms;
  1516.   #else
  1517.   #ifndef VMS
  1518. ***************
  1519. *** 390,400 ****
  1520.       } vms_times;
  1521.   #endif
  1522.   #endif
  1523.   
  1524.     if (quiet_flag)
  1525.       return 0;
  1526.   
  1527. ! #ifdef USG
  1528.     times (&tms);
  1529.     return (tms.tms_utime + tms.tms_stime) * (1000000 / HZ);
  1530.   #else
  1531. --- 406,420 ----
  1532.       } vms_times;
  1533.   #endif
  1534.   #endif
  1535. + #endif
  1536.   
  1537.     if (quiet_flag)
  1538.       return 0;
  1539.   
  1540. ! #ifdef atarist
  1541. !   return(time(NULL) * 1000000);
  1542. ! #else
  1543. ! #if (defined(USG) || defined(atariminix))
  1544.     times (&tms);
  1545.     return (tms.tms_utime + tms.tms_stime) * (1000000 / HZ);
  1546.   #else
  1547. ***************
  1548. *** 407,412 ****
  1549. --- 427,433 ----
  1550.     return (vms_times.proc_user_time + vms_times.proc_system_time) * 10000;
  1551.   #endif
  1552.   #endif
  1553. + #endif        /* atarist */
  1554.   }
  1555.   
  1556.   #define TIMEVAR(VAR, BODY)    \
  1557. ***************
  1558. *** 850,855 ****
  1559. --- 871,877 ----
  1560.     longjmp (float_handler, 1);
  1561.   }
  1562.   
  1563. + #ifndef atarist
  1564.   /* Handler for SIGPIPE.  */
  1565.   
  1566.   static void
  1567. ***************
  1568. *** 857,862 ****
  1569. --- 879,885 ----
  1570.   {
  1571.     fatal ("output pipe has been closed");
  1572.   }
  1573. + #endif
  1574.   
  1575.   /* Compile an entire file of output from cpp, named NAME.
  1576.      Write a file of assembly output and various debugging dumps.  */
  1577. ***************
  1578. *** 1735,1747 ****
  1579.     char *filename = 0;
  1580.     int print_mem_flag = 0;
  1581.     char *p;
  1582. ! 
  1583.     /* save in case md file wants to emit args as a comment.  */
  1584.     save_argc = argc;
  1585.     save_argv = argv;
  1586.   
  1587.     p = argv[0] + strlen (argv[0]);
  1588.     while (p != argv[0] && p[-1] != '/') --p;
  1589.     progname = p;
  1590.   
  1591.   #ifdef RLIMIT_STACK
  1592. --- 1758,1778 ----
  1593.     char *filename = 0;
  1594.     int print_mem_flag = 0;
  1595.     char *p;
  1596. ! #ifdef atarist
  1597. ! /* turn this on if you are going to set the TOS 1.4 dont clear heap flag */
  1598. ! /*  _malloczero(1); */     /* zero mallocs by default */
  1599. ! #endif  
  1600.     /* save in case md file wants to emit args as a comment.  */
  1601.     save_argc = argc;
  1602.     save_argv = argv;
  1603.   
  1604.     p = argv[0] + strlen (argv[0]);
  1605. + #ifndef atarist
  1606.     while (p != argv[0] && p[-1] != '/') --p;
  1607. + #else
  1608. +   while (p != argv[0] && ( ((p[-1] != '/') || (p[-1] != '\\')) &&
  1609. +               (p[-2] != ':') ) ) --p;
  1610. + #endif
  1611.     progname = p;
  1612.   
  1613.   #ifdef RLIMIT_STACK
  1614. ***************
  1615. *** 1758,1764 ****
  1616. --- 1789,1797 ----
  1617.   
  1618.     signal (SIGFPE, float_signal);
  1619.   
  1620. + #ifndef atarist
  1621.     signal (SIGPIPE, pipe_closed);
  1622. + #endif
  1623.   
  1624.     /* Initialize whether `char' is signed.  */
  1625.     flag_signed_char = DEFAULT_SIGNED_CHAR;
  1626. ***************
  1627. *** 1788,1793 ****
  1628. --- 1821,1836 ----
  1629.       else if (!strcmp (str, "dumpbase"))
  1630.         {
  1631.           dump_base_name = argv[++i];
  1632. + #ifdef atarist
  1633. + /* dump_base_name will typically be 'foo.c' here.  Need to truncate at the '.',
  1634. +    cause dots mean something here */
  1635. +         {
  1636. +           char * n = dump_base_name;
  1637. +           for ( ; ((*n) && (*n != '.')) ; )
  1638. +         n++;
  1639. +           *n = '\0';
  1640. +         }
  1641. + #endif
  1642.         }
  1643.       else if (str[0] == 'd')
  1644.         {
  1645. ***************
  1646. *** 1990,1995 ****
  1647. --- 2033,2039 ----
  1648.   
  1649.     compile_file (filename);
  1650.   
  1651. + #if (!(defined(atarist) || defined(atariminix)))
  1652.   #ifndef USG
  1653.   #ifndef VMS
  1654.     if (print_mem_flag)
  1655. ***************
  1656. *** 2005,2011 ****
  1657.       }
  1658.   #endif /* not VMS */
  1659.   #endif /* not USG */
  1660. ! 
  1661.     if (errorcount)
  1662.       exit (FATAL_EXIT_CODE);
  1663.     if (sorrycount)
  1664. --- 2049,2055 ----
  1665.       }
  1666.   #endif /* not VMS */
  1667.   #endif /* not USG */
  1668. ! #endif /* atarist or atariminix */
  1669.     if (errorcount)
  1670.       exit (FATAL_EXIT_CODE);
  1671.     if (sorrycount)
  1672.